The Benefits of Duality in Verifying Concurrent Programs under TSO

We address the problem of verifying safety properties of concurrent programs running over the TSO memory model. Known decision procedures for this model are based on complex encodings of store buffers as lossy channels. These procedures assume that the number of processes is fixed. However, it is important in general to prove correctness of a system/algorithm in a parametric way with an arbitrarily large number of processes. In this paper, we introduce an alternative (yet equivalent) semantics to the classical one for the TSO model that is more amenable for efficient algorithmic verification and for extension to parametric verification. For that, we adopt a dual view where load buffers are used instead of store buffers. The flow of information is now from the memory to load buffers. We show that this new semantics allows (1) to simplify drastically the safety analysis under TSO, (2) to obtain a spectacular gain in efficiency and scalability compared to existing procedures, and (3) to extend easily the decision procedure to the parametric case, which allows to obtain a new decidability result, and more importantly, a verification algorithm that is more general and more efficient in practice than the one for bounded instances

Optimal Stateless Model Checking under the Release-Acquire Semantics

We present a framework for the efficient application of stateless model checking (SMC) to concurrent programs running under the Release-Acquire (RA) fragment of the C/C++11 memory model. Our approach is based on exploring the possible program orders, which define the order in which instructions of a thread are executed, and read-from relations, which specify how reads obtain their values from writes. This is in contrast to previous approaches, which also explore the possible coherence orders, i.e., orderings between conflicting writes. Since unexpected test results such as program crashes or assertion violations depend only on the read-from relation, we avoid a potentially significant source of redundancy. Our framework is based on a novel technique for determining whether a particular read-from relation is feasible under the RA semantics. We define an SMC algorithm which is provably optimal in the sense that it explores each program order and read-from relation exactly once. This optimality result is strictly stronger than previous analogous optimality results, which also take coherence order into account. We have implemented our framework in the tool Tracer. Experiments show that Tracer can be significantly faster than state-of-the-art tools that can handle the RA semantics.Comment: Accepted paper in OOPSLA'1

Optimal operation of Hoa Binh reservoir for flood control on Hong-Thai Binh river system

In the paper the optimal operation of Hoabinh reservoir for flood control on Hong–Thai Binh river system is presented. The findings show that in the flood season in 1996 if the operation of gates and outlets of Hoa Binh reservoir was made base on the calculated release, the water level at Hanoi would be 12.3 m and the water level of Hoa Binh reservoir would be 98 m. So the calculated release from Hoabinh reservoir in August 1996 can be considered as optimal in the mean that the water level at Hanoi can be controlled and the Hoabinh reservoir still have necessary pool for controlling the next floods

Synthesis and Characterization of Silver Nanoplates by a Seed-mediated Method

Silver nanoplates (SNPs) having different size were synthesized by a seed-mediated method. The seeds -silver nanoparticles with 4 – 6 nm diameters were synthesized first by reducing silver nitrate with sodium borohydride in the present of Trisodium Citrate and Hydrogen peroxide. Then these seeds were developed by continue reducing Ag$^+$ ions with various amount of L-Ascorbic acid to form SNPs. Our analysis showed that the concentratrion of L-Ascorbic acid, a secondary reducing agent, played an important role to form SNPs. In addition, the size and in-plane dipole plasmon resonance wavelenght of silver nanoplates were increased when the concentration of added silver nitrate increased. The characterization of SNPs were studied by UV-Vis, FE-SEM, EDS and TEM methods

Ensuring The Correctness of Concurrent Programs under TSO Memory Models

For efficiency reasons, most modern processor architectures allow the reordering of CPU instructions, resulting in weak memory models. These models add extra program executions that are not intended by the programmer, often causing subtle run-time errors.  To help solve this problem, such architectures also provide memory fences that allow to eliminate undesired behaviors. However, manual fence insertion, is a tedious and time- consuming activity, that also needs to be repeated each time the program is updated. Therefore, the development of efficient tools for automatic fence insertion is a crucial challenge in concurrent program design. In this thesis, we present, for the first time, a tool for automatic fence placement that is able to break the scalability barrier both concerning the added complexity due to the presence of event reorderings, and also concerning the number of threads that participate in the execution of the program. To this end, we propose a novel notion of correctness  for concurrent  programs, called persistence, that compares the behavior of the program under the weak memory semantics with that under the classical interleaving semantics. To make our ideas concrete, we consider the Total Store Ordering (TSO) memory model, and show how our method (i) allows modular reasoning that limits state space explosion due to the presence of parallel processes (threads), and (ii) abstracts away complex behaviors caused by weak memory models by translating the problem, in linear time, into a verification problem that is defined under the interleaving semantics. We have implemented a prototype  and run it successfully on all standard benchmarks, together with several challenging examples that are beyond the capability of existing methods

Ensuring The Correctness of Concurrent Programs under TSO Memory Models

For efficiency reasons, most modern processor architectures allow the reordering of CPU instructions, resulting in weak memory models. These models add extra program executions that are not intended by the programmer, often causing subtle run-time errors.  To help solve this problem, such architectures also provide memory fences that allow to eliminate undesired behaviors. However, manual fence insertion, is a tedious and time- consuming activity, that also needs to be repeated each time the program is updated. Therefore, the development of efficient tools for automatic fence insertion is a crucial challenge in concurrent program design. In this thesis, we present, for the first time, a tool for automatic fence placement that is able to break the scalability barrier both concerning the added complexity due to the presence of event reorderings, and also concerning the number of threads that participate in the execution of the program. To this end, we propose a novel notion of correctness  for concurrent  programs, called persistence, that compares the behavior of the program under the weak memory semantics with that under the classical interleaving semantics. To make our ideas concrete, we consider the Total Store Ordering (TSO) memory model, and show how our method (i) allows modular reasoning that limits state space explosion due to the presence of parallel processes (threads), and (ii) abstracts away complex behaviors caused by weak memory models by translating the problem, in linear time, into a verification problem that is defined under the interleaving semantics. We have implemented a prototype  and run it successfully on all standard benchmarks, together with several challenging examples that are beyond the capability of existing methods

Model Checking of Software Systems under Weak Memory Models

When a program is compiled and run on a modern architecture, different optimizations may be applied to gain in efficiency. In particular, the access operations (e.g., read and write) to the shared memory may be performed in an out-of-order manner, i.e., in a different order than the order in which the operations have been issued by the program. The reordering of memory access operations leads to efficient use of instruction pipelines and thus an improvement in program execution times. However, the gain in this efficiency comes at a price. More precisely, programs running under modern architectures may exhibit unexpected behaviors by programmers. The out-of-order execution has led to the invention of new program semantics, called weak memory model (WMM). One crucial problem is to ensure the correctness of concurrent programs running under weak memory models. The thesis proposes three techniques for reasoning and analyzing concurrent programs running under WMMs. The first one is a sound and complete analysis technique for finite-state programs running under the TSO semantics (Paper II). This technique is based on a novel and equivalent semantics for TSO, called Dual TSO semantics, and on the use of well-structured transition framework. The second technique is an under-approximation technique that can be used to detect bugs under the POWER semantics (Paper III). This technique is based on bounding the number of contexts in an explored execution where, in each context, there is only one active process. The third technique is also an under-approximation technique based on systematic testing (a.k.a. stateless model checking). This approach has been used to develop an optimal and efficient systematic testing approach for concurrent programs running under the Release-Acquire semantics (Paper IV). The thesis also considers the problem of effectively finding a minimal set of fences that guarantees the correctness of a concurrent program running under WMMs (Paper I). A fence (a.k.a. barrier) is an operation that can be inserted in the program to prohibit certain reorderings between operations issued before and after the fence. Since fences are expensive, it is crucial to automatically find a minimal set of fences to ensure the program correctness. This thesis presents a method for automatic fence insertion in programs running under the TSO semantics that offers the best-known trade-off between the efficiency and optimality of the algorithm. The technique is based on a novel notion of correctness, called Persistence, that compares the behaviors of a program running under WMMs to that running under the SC semantics.UPMAR

Model Checking of Software Systems under Weak Memory Models

When a program is compiled and run on a modern architecture, different optimizations may be applied to gain in efficiency. In particular, the access operations (e.g., read and write) to the shared memory may be performed in an out-of-order manner, i.e., in a different order than the order in which the operations have been issued by the program. The reordering of memory access operations leads to efficient use of instruction pipelines and thus an improvement in program execution times. However, the gain in this efficiency comes at a price. More precisely, programs running under modern architectures may exhibit unexpected behaviors by programmers. The out-of-order execution has led to the invention of new program semantics, called weak memory model (WMM). One crucial problem is to ensure the correctness of concurrent programs running under weak memory models. The thesis proposes three techniques for reasoning and analyzing concurrent programs running under WMMs. The first one is a sound and complete analysis technique for finite-state programs running under the TSO semantics (Paper II). This technique is based on a novel and equivalent semantics for TSO, called Dual TSO semantics, and on the use of well-structured transition framework. The second technique is an under-approximation technique that can be used to detect bugs under the POWER semantics (Paper III). This technique is based on bounding the number of contexts in an explored execution where, in each context, there is only one active process. The third technique is also an under-approximation technique based on systematic testing (a.k.a. stateless model checking). This approach has been used to develop an optimal and efficient systematic testing approach for concurrent programs running under the Release-Acquire semantics (Paper IV). The thesis also considers the problem of effectively finding a minimal set of fences that guarantees the correctness of a concurrent program running under WMMs (Paper I). A fence (a.k.a. barrier) is an operation that can be inserted in the program to prohibit certain reorderings between operations issued before and after the fence. Since fences are expensive, it is crucial to automatically find a minimal set of fences to ensure the program correctness. This thesis presents a method for automatic fence insertion in programs running under the TSO semantics that offers the best-known trade-off between the efficiency and optimality of the algorithm. The technique is based on a novel notion of correctness, called Persistence, that compares the behaviors of a program running under WMMs to that running under the SC semantics.UPMAR

Ensuring The Correctness of Concurrent Programs under TSO Memory Models

For efficiency reasons, most modern processor architectures allow the reordering of CPU instructions, resulting in weak memory models. These models add extra program executions that are not intended by the programmer, often causing subtle run-time errors.  To help solve this problem, such architectures also provide memory fences that allow to eliminate undesired behaviors. However, manual fence insertion, is a tedious and time- consuming activity, that also needs to be repeated each time the program is updated. Therefore, the development of efficient tools for automatic fence insertion is a crucial challenge in concurrent program design. In this thesis, we present, for the first time, a tool for automatic fence placement that is able to break the scalability barrier both concerning the added complexity due to the presence of event reorderings, and also concerning the number of threads that participate in the execution of the program. To this end, we propose a novel notion of correctness  for concurrent  programs, called persistence, that compares the behavior of the program under the weak memory semantics with that under the classical interleaving semantics. To make our ideas concrete, we consider the Total Store Ordering (TSO) memory model, and show how our method (i) allows modular reasoning that limits state space explosion due to the presence of parallel processes (threads), and (ii) abstracts away complex behaviors caused by weak memory models by translating the problem, in linear time, into a verification problem that is defined under the interleaving semantics. We have implemented a prototype  and run it successfully on all standard benchmarks, together with several challenging examples that are beyond the capability of existing methods

Experimental and computational investigations on fire resistance of GFRP composite for building facade

Composite materials such as glass fibre reinforced polymers (GFRPs) possess the advantages of high strength and stiffness, as well as low density and highly flexible tailoring; therefore, their potential in replacing conventional materials (such as concrete, aluminium and steel) in building façade has become attractive. This paper addresses one of the major issues that hinder the extensive use of composite structures in the high-rise building industry, which is the fire resistance. In this study, a fire performance enhancement strategy for multilayer composite sandwich panels, which are comprised of GFRP composite facets and polyethylene foam core, is proposed with the addition of environmentally friendly, fire retardant unsaturated polyester resins and gel-coats. A series of burning experimental studies including thermo-gravimetric analysis (TGA) and single burning item (SBI) are carried out on the full scale composite sandwich as well as on single constituents, providing information regarding heat release rate, total heat release, fire growth rate, and smoke production. Experimental results are compared with fire safety codes for building materials to identify the key areas for improvements. A fire dynamic numerical model has been developed in this work using the Fire Dynamics Simulator (FDS) to simulate the burning process of composite structures in the SBI test. Numerical results of heat production and growth rate are presented in comparison with experimental observations validating the computational model and provide further insights into the fire resisting process. Parametric studies are conducted to investigate the effect of fire retardant additives on the fire performance of the composite sandwich panel leading to optimum designs for the sandwich panel